/// Phase 1 基础功能测试
/// 这些测试验证Phase 1的核心功能是否正确实现

#[test]
fn test_project_structure_phase1() {
    // 验证Phase 1要求的项目结构
    
    // 1. Fluvio集群搭建和配置相关文件
    assert!(std::path::Path::new("backend/shared/src/fluvio_manager.rs").exists(), 
           "Fluvio管理器模块应该存在");
    
    // 2. 基础Web UI开发相关文件
    assert!(std::path::Path::new("frontend/package.json").exists(), 
           "前端package.json应该存在");
    assert!(std::path::Path::new("frontend/src/App.tsx").exists(), 
           "前端App组件应该存在");
    assert!(std::path::Path::new("frontend/src/components/Sidebar.tsx").exists(), 
           "侧边栏组件应该存在");
    assert!(std::path::Path::new("frontend/src/components/Header.tsx").exists(), 
           "头部组件应该存在");
    
    // 3. 核心API服务相关文件
    assert!(std::path::Path::new("backend/api-gateway/src/main.rs").exists(), 
           "API网关主文件应该存在");
    assert!(std::path::Path::new("backend/api-gateway/src/routes.rs").exists(), 
           "API路由文件应该存在");
    assert!(std::path::Path::new("backend/api-gateway/src/handlers").exists(), 
           "API处理器目录应该存在");
    
    // 4. 基本连接器框架相关文件
    assert!(std::path::Path::new("backend/shared/src/models.rs").exists(), 
           "数据模型文件应该存在");
    assert!(std::path::Path::new("backend/shared/src/database.rs").exists(), 
           "数据库模块应该存在");
    
    println!("✅ Phase 1 项目结构验证通过");
}

#[test]
fn test_configuration_models() {
    use fluviox_shared::{Config, models::*};
    
    // 测试配置模型
    let config = Config {
        server: fluviox_shared::config::ServerConfig {
            host: "localhost".to_string(),
            port: 8080,
            cors_origins: vec!["http://localhost:3000".to_string()],
        },
        database: fluviox_shared::config::DatabaseConfig {
            url: "postgresql://test".to_string(),
            max_connections: 10,
            min_connections: 1,
        },
        fluvio: fluviox_shared::config::FluvioConfig {
            cluster_endpoint: "localhost:9003".to_string(),
            default_partitions: 1,
            default_replication: 1,
        },
        ai: fluviox_shared::config::AiConfig {
            openai_api_key: None,
            model: "gpt-3.5-turbo".to_string(),
            max_tokens: 1000,
        },
    };
    
    assert_eq!(config.server.port, 8080);
    assert_eq!(config.fluvio.cluster_endpoint, "localhost:9003");
    
    println!("✅ 配置模型测试通过");
}

#[test]
fn test_data_models() {
    use fluviox_shared::models::*;
    use uuid::Uuid;
    use chrono::Utc;
    
    // 测试连接器模型
    let connector = Connector {
        id: Uuid::new_v4(),
        name: "test-connector".to_string(),
        connector_type: ConnectorType::Source,
        specification: ConnectorSpec {
            name: "HTTP Source".to_string(),
            version: "1.0.0".to_string(),
            description: "HTTP数据源连接器".to_string(),
            connection_specification: serde_json::json!({}),
            supported_sync_modes: vec![SyncMode::RealTime],
        },
        configuration: std::collections::HashMap::new(),
        status: ConnectorStatus::Active,
        created_at: Utc::now(),
        updated_at: Utc::now(),
    };
    
    assert_eq!(connector.name, "test-connector");
    assert!(matches!(connector.connector_type, ConnectorType::Source));
    
    // 测试连接模型
    let connection = Connection {
        id: Uuid::new_v4(),
        name: "test-connection".to_string(),
        description: Some("测试连接".to_string()),
        source_id: Uuid::new_v4(),
        destination_id: Uuid::new_v4(),
        configuration: ConnectionConfig {
            sync_mode: SyncMode::RealTime,
            schedule: None,
            transformations: vec![],
        },
        status: ConnectionStatus::Active,
        created_at: Utc::now(),
        updated_at: Utc::now(),
    };
    
    assert_eq!(connection.name, "test-connection");
    assert!(matches!(connection.configuration.sync_mode, SyncMode::RealTime));
    
    // 测试Fluvio主题模型
    let topic = FluvioTopic {
        name: "test-topic".to_string(),
        partitions: 3,
        replication_factor: 1,
        retention_time: Some(86400),
        compression: Some("gzip".to_string()),
    };
    
    assert_eq!(topic.name, "test-topic");
    assert_eq!(topic.partitions, 3);
    
    println!("✅ 数据模型测试通过");
}

#[test]
fn test_fluvio_topic_validation() {
    use fluviox_shared::fluvio_manager::is_valid_topic_name;
    
    // 测试有效的主题名称
    let valid_names = vec![
        "user-events",
        "order_data",
        "metrics123",
        "logs",
        "fluviox-events",
        "test_topic_123",
    ];
    
    for name in valid_names {
        assert!(is_valid_topic_name(name), "主题名称 '{}' 应该是有效的", name);
    }
    
    // 测试无效的主题名称
    let invalid_names = vec![
        "",
        "invalid topic",  // 包含空格
        "invalid.topic",  // 包含点
        "invalid@topic",  // 包含特殊字符
        "invalid/topic",  // 包含斜杠
        "invalid:topic",  // 包含冒号
    ];
    
    for name in invalid_names {
        assert!(!is_valid_topic_name(name), "主题名称 '{}' 应该是无效的", name);
    }
    
    println!("✅ Fluvio主题名称验证测试通过");
}

#[test]
fn test_api_routes_structure() {
    // 验证API路由文件内容
    let routes_content = std::fs::read_to_string("backend/api-gateway/src/routes.rs")
        .expect("应该能够读取routes.rs文件");
    
    // 检查必要的路由是否定义
    assert!(routes_content.contains("/health"), "应该包含健康检查路由");
    assert!(routes_content.contains("/connectors"), "应该包含连接器路由");
    assert!(routes_content.contains("/connections"), "应该包含连接路由");
    assert!(routes_content.contains("/pipelines"), "应该包含管道路由");
    assert!(routes_content.contains("/topics"), "应该包含主题路由");
    assert!(routes_content.contains("/ai"), "应该包含AI助手路由");
    
    println!("✅ API路由结构验证通过");
}

#[test]
fn test_frontend_structure() {
    // 验证前端结构
    let package_json = std::fs::read_to_string("frontend/package.json")
        .expect("应该能够读取package.json");
    
    // 检查必要的依赖
    assert!(package_json.contains("react"), "应该包含React依赖");
    assert!(package_json.contains("typescript"), "应该包含TypeScript依赖");
    assert!(package_json.contains("vite"), "应该包含Vite依赖");
    assert!(package_json.contains("antd"), "应该包含Ant Design依赖");
    assert!(package_json.contains("axios"), "应该包含Axios依赖");
    
    // 检查页面组件是否存在
    assert!(std::path::Path::new("frontend/src/pages/Dashboard.tsx").exists(), 
           "仪表板页面应该存在");
    assert!(std::path::Path::new("frontend/src/pages/Connectors.tsx").exists(), 
           "连接器页面应该存在");
    assert!(std::path::Path::new("frontend/src/pages/Connections.tsx").exists(), 
           "连接页面应该存在");
    assert!(std::path::Path::new("frontend/src/pages/Topics.tsx").exists(), 
           "主题页面应该存在");
    
    println!("✅ 前端结构验证通过");
}

#[test]
fn test_docker_configuration() {
    // 验证Docker配置
    assert!(std::path::Path::new("docker-compose.yml").exists(), 
           "Docker Compose文件应该存在");
    assert!(std::path::Path::new("backend/Dockerfile.api-gateway").exists(), 
           "API网关Dockerfile应该存在");
    assert!(std::path::Path::new("frontend/Dockerfile").exists(), 
           "前端Dockerfile应该存在");
    
    let docker_compose = std::fs::read_to_string("docker-compose.yml")
        .expect("应该能够读取docker-compose.yml");
    
    // 检查必要的服务
    assert!(docker_compose.contains("postgres"), "应该包含PostgreSQL服务");
    assert!(docker_compose.contains("fluvio"), "应该包含Fluvio服务");
    assert!(docker_compose.contains("api-gateway"), "应该包含API网关服务");
    assert!(docker_compose.contains("frontend"), "应该包含前端服务");
    
    println!("✅ Docker配置验证通过");
}
